home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / opengl / motif / obuffer.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  9.6 KB  |  357 lines
  1. /*
  2.  * Copyright 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*----------------------------------------------------------------------------
  18.  *
  19.  * obuffer : openGL (motif) demo to switch between single/double buffer mode
  20.  *
  21.  * Author : Yusuf Attarwala
  22.  *          SGI - Applications
  23.  * Date   : Jan 93
  24.  *
  25.  *    note : the main intent of this program is to demo the buffer
  26.  *           switching functionality, hence the rendering is kept
  27.  *           simple (wireframe).
  28.  * 
  29.  *    press  left   button for single buffer
  30.  *           middle button for double buffer
  31.  *           right  button for animation
  32.  *
  33.  *---------------------------------------------------------------------------*/
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36.  
  37. #include <Xm/Xm.h> 
  38. #include <Xm/Frame.h>               /* for frame widgets */
  39. #include <X11/keysym.h>             /* keyboard translations */
  40. #include <X11/StringDefs.h>
  41.  
  42. #include <GL/gl.h>                  /* gl includes */
  43. #include <GL/glu.h>                 /* utility library includes */
  44. #include <GL/GLwMDrawA.h>           /* include for the drawing area widget */
  45.  
  46. /* function declarations */
  47.  
  48. void 
  49.     createToplevel(void),
  50.     createSingleBuffer(void),
  51.     createDoubleBuffer(void),
  52.     toSingleBuffer(void),
  53.     toDoubleBuffer(void),
  54.     animation(void),
  55.     drawScene(void),
  56.     setMatrix(void),
  57.     exposeCB(Widget,XtPointer,XtPointer),
  58.     resizeCB(Widget,XtPointer,XtPointer),
  59.     initCB(Widget,XtPointer,XtPointer),
  60.     inputCB(Widget,XtPointer,XtPointer);
  61.  
  62. /* global variables */
  63.             
  64. Display      *display;             /* current display */
  65. XtAppContext appContext;           /* X application context */
  66. int           doubleBuffer;        /* flag for current buffer status */
  67. float         ax,ay,az;            /* angles for animation */
  68. GLUquadricObj *quadObj;            /* used in drawscene */
  69.  
  70. Widget       toplevel,       /* toplevel shell */
  71.              frameSB,        /* frame to hold single buffer gl widget */
  72.              frameDB,        /* frame to hold double buffer gl widget */
  73.              glwSB,
  74.              glwDB,
  75.              glw;            /* current widget */
  76.              
  77. GLXContext   glxc;           /* current glx context */
  78.  
  79. Arg args[20];
  80. int acnt;
  81.  
  82. void 
  83. main(int argc, char** argv)
  84. {
  85.     XtToolkitInitialize();
  86.     appContext = XtCreateApplicationContext();
  87.     display    = XtOpenDisplay(appContext, NULL, "Obuffer","obuffer",NULL,0,
  88.                               &argc,argv);
  89.     if (!display) {
  90.         printf("%s : Unable to open display\n",argv[0]);
  91.         exit(0);
  92.     }
  93.  
  94.     printf("\n---------------------------------------------\n");
  95.     printf("Demo to toggle single/double buffer mode \n\n");
  96.     printf("Press:  left   button for single buffer\n\
  97.         middle button for double buffer\n\
  98.         right  button for animation\n");
  99.  
  100.  
  101.     quadObj = gluNewQuadric ();   /* this will be used in drawScene */
  102.     createToplevel();             /* create widget hierarchy */
  103.     XtAppMainLoop(appContext);
  104. }
  105.  
  106.  
  107.  
  108. void
  109. createToplevel()
  110. {
  111.     acnt = 0;
  112.     XtSetArg(args[acnt],XmNminHeight, 300);acnt++;
  113.     XtSetArg(args[acnt],XmNminWidth,  300);acnt++;
  114.     XtSetArg(args[acnt],XmNminAspectX,  1);acnt++;
  115.     XtSetArg(args[acnt],XmNminAspectY,  1);acnt++;
  116.     XtSetArg(args[acnt],XmNmaxAspectX,  1);acnt++;
  117.     XtSetArg(args[acnt],XmNmaxAspectY,  1);acnt++;
  118.     toplevel  = XtAppCreateShell("toplevel","obuffer",
  119.                                   applicationShellWidgetClass,
  120.                                   display,args,acnt);
  121.  
  122.     /* create two drawing area widgets as children of
  123.        toplevel, only manage one at a time */
  124.  
  125.     createDoubleBuffer();
  126.     createSingleBuffer();
  127.  
  128.     /* realize widget hierarchy */
  129.     XtRealizeWidget(toplevel);
  130.  
  131.     toDoubleBuffer();  /* let the default be double buffer */
  132. }
  133.  
  134. void
  135. createSingleBuffer()
  136. {
  137.     acnt = 0;
  138.     frameSB = XtCreateWidget("frameSB", xmFrameWidgetClass,
  139.                               toplevel, args, acnt);
  140.  
  141.     /* NOTE : do not manage child here */
  142.  
  143.     acnt = 0;
  144.     XtSetArg(args[acnt], GLwNrgba,               TRUE); acnt++;
  145.     XtSetArg(args[acnt], GLwNdoublebuffer,       FALSE); acnt++;
  146.     XtSetArg(args[acnt], GLwNallocateBackground, TRUE); acnt++;
  147.     glwSB = GLwCreateMDrawingArea(frameSB, "glwSB", args, acnt);
  148.  
  149.     XtManageChild(glwSB);
  150.  
  151.     /* register callbacks */
  152.     XtAddCallback(glwSB, GLwNexposeCallback, exposeCB, NULL);
  153.     XtAddCallback(glwSB, GLwNresizeCallback, resizeCB, NULL);
  154.     XtAddCallback(glwSB, GLwNginitCallback,  initCB,   NULL);
  155.     XtAddCallback(glwSB, GLwNinputCallback,  inputCB,  NULL);
  156.  
  157. }
  158.  
  159. void
  160. createDoubleBuffer()
  161. {
  162.     acnt = 0;
  163.     frameDB = XtCreateWidget("frameDB", xmFrameWidgetClass,
  164.                               toplevel, args, acnt);
  165.  
  166.     XtManageChild(frameDB);
  167.  
  168.     acnt = 0;
  169.     XtSetArg(args[acnt], GLwNrgba,               TRUE); acnt++;
  170.     XtSetArg(args[acnt], GLwNdoublebuffer,       TRUE); acnt++;  /* NOTE */
  171.     XtSetArg(args[acnt], GLwNallocateBackground, TRUE); acnt++;
  172.     glwDB = GLwCreateMDrawingArea(frameDB, "glwDB", args, acnt);
  173.  
  174.     XtManageChild(glwDB);
  175.  
  176.     /* register callbacks */
  177.     XtAddCallback(glwDB, GLwNexposeCallback, exposeCB, NULL);
  178.     XtAddCallback(glwDB, GLwNresizeCallback, resizeCB, NULL);
  179.     XtAddCallback(glwDB, GLwNginitCallback,  initCB,   NULL);
  180.     XtAddCallback(glwDB, GLwNinputCallback,  inputCB,  NULL);
  181.  
  182. }
  183.  
  184. void
  185. toSingleBuffer(void)
  186. {
  187.     acnt = 0;
  188.     XtSetArg(args[acnt],XmNtitle, "SINGLE buffer");acnt++;
  189.     XtSetValues(toplevel,args,acnt);
  190.  
  191.     XtManageChild(frameSB);
  192.     XtUnmanageChild(frameDB);
  193.     glw = glwSB;
  194.     doubleBuffer = FALSE;
  195.  
  196.     XtSetArg(args[0], XmNuserData, &glxc);
  197.     XtGetValues(glw, args, 1);
  198.     GLwDrawingAreaMakeCurrent(glw, glxc);
  199.     setMatrix();
  200.     drawScene();
  201. }
  202.  
  203. void
  204. toDoubleBuffer(void)
  205. {
  206.     acnt = 0;
  207.     XtSetArg(args[acnt],XmNtitle, "DOUBLE buffer");acnt++;
  208.     XtSetValues(toplevel,args,acnt);
  209.  
  210.     XtManageChild(frameDB);
  211.     XtUnmanageChild(frameSB);
  212.     glw = glwDB;
  213.     doubleBuffer = TRUE;
  214.  
  215.     XtSetArg(args[0], XmNuserData, &glxc);
  216.     XtGetValues(glw, args, 1);
  217.     GLwDrawingAreaMakeCurrent(glw, glxc);
  218.     setMatrix();
  219.     drawScene();
  220.  
  221. }
  222.  
  223. void
  224. drawScene(void)
  225. {
  226.     glClearColor(0.0, 0.0, 0.0, 0.0);
  227.     glClear(GL_COLOR_BUFFER_BIT);
  228.  
  229.     glPushMatrix();
  230.     gluQuadricDrawStyle (quadObj, GLU_LINE);
  231.     glColor3f (0.7, 0.3, 1.0);
  232.     glTranslatef (12.0,12.0,0.0);
  233.     glRotatef(ax,1.0,0.0,0.0);
  234.     glRotatef(-ay,0.0, 1.0, 0.0);
  235.     gluCylinder (quadObj, 2.0,5.0,10.0,16,6);
  236.     glPopMatrix();
  237.  
  238.     glPushMatrix();
  239.     gluQuadricDrawStyle (quadObj, GLU_FILL);
  240.     glColor3f (3.2, 0.8, 1.0);
  241.     glTranslatef (15.0,15.0,0.0);
  242.     glRotatef(ax,1.0,0.0,0.0);
  243.     glRotatef(ay,0.0, 1.0, 0.0);
  244.     glRotatef(az,0.0,0.0,1.0);
  245.     gluDisk(quadObj,2.0,5.0,16,4);
  246.  
  247.     gluQuadricDrawStyle (quadObj, GLU_SILHOUETTE);
  248.     glColor3f (1.0, 0.2, 1.0);
  249.     glTranslatef (7.0,7.0,0.0);
  250.     glRotatef(-ax,1.0,0.0,0.0);
  251.     glRotatef(az,0.0,0.0,1.0);
  252.     gluPartialDisk (quadObj, 0.0,5.0,20,3,135.0,270.0);
  253.  
  254.     glPopMatrix();
  255.     glFlush();
  256.  
  257.     if (doubleBuffer) glXSwapBuffers(XtDisplay(glw), XtWindow(glw));
  258. }
  259.  
  260. void
  261. setMatrix(void)
  262. {
  263.     glMatrixMode(GL_PROJECTION);
  264.     glLoadIdentity();
  265.     glOrtho(0.0,32.0,0.0,32.0,-15.0,15.0);
  266.     glMatrixMode(GL_MODELVIEW);
  267.     glLoadIdentity();
  268. }
  269.  
  270. void
  271. animation(void)
  272. {
  273.     register int i;
  274.  
  275.     for (i=0;i<70;i++) {
  276.         ax += 5.0;
  277.         ay -= 2.0;
  278.         az += 5.0;
  279.         if (ax >= 3600)  ax = 0.0;
  280.         if (ay <= -3600) ay = 0.0;
  281.         if (az >= 3600)  az = 0.0;
  282.         drawScene();
  283.     }
  284. }
  285.  
  286. void 
  287. inputCB(Widget w, XtPointer client_data, XtPointer call)
  288. {
  289.     char buffer[1];
  290.     KeySym keysym;
  291.     GLwDrawingAreaCallbackStruct *call_data;
  292.  
  293.     call_data = (GLwDrawingAreaCallbackStruct *) call;
  294.  
  295.     switch(call_data->event->type) {
  296.     case ButtonPress:
  297.         switch (call_data->event->xbutton.button) {
  298.         case Button1:
  299.             toSingleBuffer();
  300.             break;
  301.         case Button2 :
  302.             toDoubleBuffer();
  303.             break;
  304.         case Button3 :
  305.             animation();
  306.             break;
  307.         }
  308.         break;
  309.     default:
  310.         break;
  311.     }
  312. }
  313.  
  314. void 
  315. resizeCB(Widget w, XtPointer client_data, XtPointer call)
  316. {
  317.     GLwDrawingAreaCallbackStruct *call_data;
  318.     call_data = (GLwDrawingAreaCallbackStruct *) call;
  319.  
  320.     XtSetArg(args[0], XmNuserData, &glxc);
  321.     XtGetValues(w, args, 1);
  322.  
  323.     GLwDrawingAreaMakeCurrent(w, glxc);
  324.     glViewport(0, 0, call_data->width, call_data->height);
  325.     drawScene();
  326. }
  327.  
  328. void 
  329. exposeCB(Widget w, XtPointer client_data, XtPointer call)
  330. {
  331.     GLwDrawingAreaCallbackStruct *call_data;
  332.     call_data = (GLwDrawingAreaCallbackStruct *) call;
  333.  
  334.     XtSetArg(args[0], XmNuserData, &glxc);
  335.     XtGetValues(w, args, 1);
  336.  
  337.     GLwDrawingAreaMakeCurrent(w, glxc);
  338.     drawScene();
  339. }
  340.  
  341. void
  342. initCB(Widget w, XtPointer client_data, XtPointer call)
  343. {
  344.     XVisualInfo *vi;
  345.  
  346.     XtSetArg(args[0], GLwNvisualInfo, &vi);
  347.     XtGetValues(w, args, 1);
  348.  
  349.     glxc = glXCreateContext(XtDisplay(w), vi, 0, GL_TRUE);
  350.     XtSetArg(args[0], XmNuserData, glxc);
  351.     XtSetValues(w, args, 1);
  352.  
  353. }
  354.  
  355.  
  356.  
  357.